Summary

Adds an overridable TestRunner#around_test(test) hook so instrumentation can be scoped to a single test. Addresses #796.

Motivation

TestRunner runs an entire test run in one call stack (Inferno::Jobs::ExecuteTestRun#perform -> TestRunner#start -> recursive #run). When a deployment adds distributed tracing (for example OpenTelemetry auto-instrumentation around the Sidekiq worker), the span at the top of that job becomes the trace root and every downstream request the run makes nests under it, so the whole run collapses into a single trace.

That trace is long-lived (many minutes) and very large (we have seen roughly 10,000 spans in one run), which is hard to use for two reasons that are independent of any particular backend:

• A trace is meant to represent one logical operation. A multi-minute waterfall with thousands of spans is not something a trace UI renders well or a person reads usefully.
• Trace stores impose a per-trace size limit (for example Grafana Tempo's max_bytes_per_trace, 5 MB by default) and silently drop spans past it, so the tail of a large run is lost.

The natural unit for a test runner is the test, but there is currently no seam to hang per-test instrumentation on without monkeypatching run_test's body (which is fragile against internal changes).

Change

• Add around_test(test), which yields by default and can be overridden or prepended to wrap each test's execution (a distinct span or trace per test, a timing metric, and so on).
• Wrap the body of run_test in around_test(test) { ... }.
• Fold the single-test early return into update_parent_result(test.parent) if test_run.test_id.present? so the wrapped block always runs to completion (behaviour is unchanged; it just avoids a return unwinding out of the hook block).

No new dependencies. The hook is generic: tracing is the motivating case, but it works equally for metrics, timing, or logging.

Example (downstream, OpenTelemetry)

module PerTestTraceRoot
  def around_test(test)
    tracer = OpenTelemetry.tracer_provider.tracer('inferno')
    # Detach from the enclosing run/job span so each test starts its own trace.
    OpenTelemetry::Context.with_current(OpenTelemetry::Context.empty) do
      tracer.in_span("inferno.test #{test.id}",
                     attributes: { 'inferno.test_run_id' => test_run.id, 'inferno.test_id' => test.id }) do
        super
      end
    end
  end
end
Inferno::TestRunner.prepend(PerTestTraceRoot)

This turns one unbounded per-run trace into one bounded, queryable trace per test, correlated by inferno.test_run_id.

Tests

• around_test yields and returns the block's value by default.
• around_test is invoked once per executed test during a run.

bundle exec rspec spec/inferno/test_runner_spec.rb passes (17 examples, 0 failures) and bundle exec rubocop is clean on the changed files.